1
2
3
4
Kolejny
Znajdź indeks elementu tablicy, który chcesz usunąć za pomocą indexOf, a następnie usuń ten indeks za pomocą splice.
Metoda splice () zmienia zawartość tablicy poprzez usunięcie
istniejące elementy i / lub dodanie nowych elementów.
tablica const = [2, 5, 9];
console.log (tablica);
const index = array.indexOf (5);
if (indeks> -1) {
array.splice (indeks, 1);
}
// tablica = [2, 9]
console.log (tablica);
Drugim parametrem złącza jest liczba elementów do usunięcia. Zwróć uwagę, że splice modyfikuje tablicę w miejscu i zwraca nową tablicę zawierającą elementy, które zostały usunięte.
Ze względu na kompletność tutaj są funkcje. Pierwsza funkcja usuwa tylko jedno wystąpienie (tj. Usuwa pierwsze dopasowanie 5 z [2,5,9,1,5,8,5]), natomiast druga funkcja usuwa wszystkie wystąpienia:
function removeItemOnce (arr, value) {
var index = arr.indexOf (wartość);
if (indeks> -1) {
arr.splice (indeks, 1);
}
powrót arr;
}
function removeItemAll (arr, value) {
var i = 0;
while (i = 0; i--) {
if (tablica [i] === liczba) {
array.splice (i, 1);
}
}
Jeśli chcesz tylko, aby element w indeksie już nie istniał, ale nie chcesz, aby indeksy innych elementów się zmieniały:
usuń tablicę [i];
|
Wydane w październiku 2016 r
Zrób to prosto, intuicyjnie i wyraźnie (brzytwa Ockhama)
Zrób to niezmienne (oryginalna tablica pozostaje niezmieniona)
Zrób to ze standardowymi funkcjami JavaScript, jeśli Twoja przeglądarka ich nie obsługuje - użyj polyfill
W tym przykładzie kodu używam funkcji "array.filter (...)" do usuwania niechcianych elementów z tablicy. Ta funkcja nie zmienia oryginalnej tablicy i tworzy nową. Jeśli Twoja przeglądarka nie obsługuje tej funkcji (np. Internet Explorer przed wersją 9 lub Firefox przed wersją 1.5), rozważ użycie wypełnienia filtru z Mozilli.
Usuwanie elementu (kod ECMA-262 wydanie 5, inaczej JavaScript w starym stylu)
wartość var = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (function (item) {
zwróć przedmiot! == wartość
})
console.log (arr)
// [1, 2, 4, 5]
Usuwanie pozycji (kod ECMAScript 6)
niech wartość = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == value)
console.log (arr)
// [1, 2, 4, 5]
WAŻNE ECMAScript 6 "() => {}" składnia funkcji strzałek nie jest w ogóle obsługiwana w przeglądarce Internet Explorer, Chrome przed wersją 45, Firefox przed wersją 22 i Safari przed wersją 10. Aby użyć składni ECMAScript 6 w starszych przeglądarkach, możesz użyć BabelJS.
Usuwanie wielu elementów (kod ECMAScript 7)
Dodatkową zaletą tej metody jest to, że można usunąć wiele elementów
let forDeletion = [2, 3, 5]
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Przeczytaj poniżej o obsłudze array.includes (...) !!!
console.log (arr)
// [1, 4]
WAŻNE Funkcja "array.includes (...)" nie jest w ogóle obsługiwana w Internet Explorerze, Chrome przed wersją 47, Firefox przed wersją 43, Safari przed wersją 9 i Edge przed wersją 14, więc oto wypełniacz z Mozilli.
Usuwanie wielu elementów (może w przyszłości)
Jeśli propozycja „This-Binding Syntax” zostanie kiedykolwiek zaakceptowana, będziesz w stanie to zrobić:
// tablica-lib.js
funkcja eksportu remove (... forDeletion) {
return this.filter (item =>! forDeletion.includes (item))
}
// main.js
import {remove} from „./array-lib.js”
let arr = [1, 2, 3, 4, 5, 3]
// :: Propozycja składni tego powiązania
// używanie funkcji „usuń” jako „metody wirtualnej”
// bez rozszerzania Array.prototype
arr = arr :: remove (2, 3, 5)
console.log (arr)
// [1, 4]
Spróbuj sam w BabelJS :)
Odniesienie
Array.prototype.includes
Kompozycja funkcjonalna
|
Zależy to od tego, czy chcesz zachować puste miejsce, czy nie.
Jeśli chcesz mieć puste miejsce:
tablica [indeks] = niezdefiniowany;
Jeśli nie chcesz mieć pustego miejsca:
// Aby zachować oryginał:
// oldArray = [... tablica];
// To modyfikuje tablicę.
array.splice (indeks, 1);
A jeśli potrzebujesz wartości tego elementu, możesz po prostu zapisać element zwróconej tablicy:
wartość zmienna = tablica.splice (indeks, 1) [0];
Jeśli chcesz usunąć jeden z końców tablicy, możesz użyć array.pop () dla ostatniej lub array.shift () dla pierwszej (oba zwracają również wartość elementu).
Jeśli nie znasz indeksu elementu, możesz użyć array.indexOf (item), aby go pobrać (w if (), aby uzyskać jeden element lub w while (), aby uzyskać wszystkie). array.indexOf (item) zwraca indeks lub -1, jeśli nie zostanie znaleziony.
|
Znajomy miał problemy z Internet Explorerem 8 i pokazał mi, co zrobił. Powiedziałem mu, że to źle, a on powiedział mi, że otrzymał odpowiedźtutaj. Bieżąca najlepsza odpowiedź nie będzie działać we wszystkich przeglądarkach (na przykład Internet Explorer 8) i usunie tylko pierwsze wystąpienie elementu.
Usuń WSZYSTKIE instancje z tablicy
function array_remove_index_by_value (arr, item)
{
for (var i = arr.length; i--;)
{
if (arr [i] === item) {arr.splice (i, 1);}
}
}
Wykonuje pętlę w tablicy wstecz (ponieważ indeksy i długość zmieniają się, gdy elementy są usuwane) i usuwa element, jeśli zostanie znaleziony. Działa we wszystkich przeglądarkach.
|
Istnieją dwa główne podejścia:
splice (): anArray.splice (indeks, 1);
delete: delete anArray [indeks];
Zachowaj ostrożność, gdy używasz usuwania dla tablicy. Jest dobry do usuwania atrybutów obiektów, ale nie jest tak dobry dla tablic. Dla tablic lepiej jest używać łączenia.
Pamiętaj, że jeśli używasz delete dla tablicy, możesz uzyskać błędne wyniki dla anArray.length. Innymi słowy, delete usunie element, ale nie zaktualizuje wartości właściwości length.
Możesz również spodziewać się dziur w numerach indeksów po użyciu funkcji usuwania, np. możesz skończyć z indeksami 1, 3, 4, 8, 9 i 11 oraz długością, tak jak przed użyciem usuwania. W takim przypadku wszystkie indeksowane pętle for uległyby awarii, ponieważ indeksy nie są już sekwencyjne.
Jeśli z jakiegoś powodu jesteś zmuszony użyć usuwania, powinieneś użyć dla każdej pętli, gdy potrzebujesz pętli przez tablice. W rzeczywistości zawsze unikaj używania indeksowanych pętli for, jeśli to możliwe. W ten sposób kod byłby bardziej niezawodny i mniej podatny na problemy z indeksami.
|
Array.prototype.remove_by_value = function (val) {
for (var i = 0; i row.id === 5);
var remove = helper.remove (arr, row => row.name.startsWith ('BMW'));
##Definicja
var helper = {
// Usuń i zwróć pierwsze wystąpienie
removeOne: function (tablica, predykat) {
for (var i = 0; i [2, 3, 4]
|
Możesz użyć ES6. Na przykład, aby usunąć wartość „3” w tym przypadku:
zmienna tablica = ['1', '2', '3', '4', '5', '6']
var nowa tablica = tablica.filter ((wartość) => wartość! = '3');
console.log (newArray);
Wynik :
[„1”, „2”, „4”, „5”, „6”]
|
Jeśli chcesz utworzyć nową tablicę z usuniętymi pozycjami, zawsze możesz usunąć określony element i odfiltrować tablicę. Może wymagać rozszerzenia obiektu tablicy dla przeglądarek, które nie implementują metody filtru, ale w dłuższej perspektywie jest to łatwiejsze, ponieważ wszystko, co robisz, to:
var my_array = [1, 2, 3, 4, 5, 6];
usuń my_array [4];
console.log (my_array.filter (function (a) {return typeof a! == 'undefined';}));
Powinien wyświetlić [1, 2, 3, 4, 6].
|
Oto kilka sposobów na usunięcie elementu z tablicy za pomocą JavaScript.
Wszystkie opisane metody nie powodują mutacji oryginalnej tablicy, a zamiast tego tworzą nową.
Jeśli znasz indeks pozycji
Załóżmy, że masz tablicę i chcesz usunąć element z pozycji i.
Jedną z metod jest użycie slice ():
elementy const = [„a”, „b”, „c”, „d”, „e”, „f”]
const i = 3
const filterItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (filterItems)
slice () tworzy nową tablicę z indeksami, które otrzymuje. Po prostu tworzymy nową tablicę, od początku do indeksu, który chcemy usunąć, i łączymy kolejną tablicę od pierwszej pozycji po tej, którą usunęliśmy, aż do końca tablicy.
Jeśli znasz wartość
W tym przypadku dobrą opcją jest użycie funkcji filter (), która oferuje bardziej deklaratywne podejście:
elementy const = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filterItems = items.filter (item => item! == valueToRemove)
console.log (filterItems)
Wykorzystuje funkcje strzałek ES6. Możesz użyć tradycyjnych funkcji do obsługi starszych przeglądarek:
elementy const = [„a”, „b”, „c”, „d”, „e”, „f”]
const valueToRemove = 'c'
const filterItems = items.filter (function (item) {
zwróć przedmiot! == valueToRemove
})
console.log (filterItems)
lub możesz użyć Babel i przetransponować kod ES6 z powrotem do ES5, aby uczynić go bardziej zrozumiałym dla starych przeglądarek, ale pisz w swoim kodzie nowoczesny JavaScript.
Usuwanie wielu elementów
A co jeśli zamiast jednego elementu chcesz usunąć wiele elementów?
Znajdźmy najprostsze rozwiązanie.
Według indeksu
Możesz po prostu utworzyć funkcję i usuwać elementy w serii:
elementy const = ['a', 'b', 'c', 'd', 'e', 'f']
const removeItem = (items, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
let filterItems = removeItem (items, 3)
filterItems = removeItem (filterItems, 5)
// ["a", "b", "c", "d"]
console.log (filterItems)
Według wartości
Możesz szukać włączenia wewnątrz funkcji wywołania zwrotnego:
elementy const = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filterItems = items.filter (item =>! valuesToRemove.includes (item))
// ["a", "b", "e", "f"]
console.log (filterItems)
Unikaj mutowania oryginalnej tablicy
splice () (nie mylić z slice ()) modyfikuje oryginalną tablicę i należy go unikać.
(pierwotnie opublikowane na mojej stronie https://flaviocopes.com/how-to-remove-item-from-array/)
|
Sprawdź ten kod. Działa w każdej większej przeglądarce.
remove_item = function (arr, value) {
var b = '';
for (b in arr) {
if (arr [b] === wartość) {
arr.splice (b, 1);
przerwa;
}
}
powrót arr;
};
Wywołaj tę funkcję
remove_item (tablica, wartość);
|
ES6 i bez mutacji: (październik 2016)
const removeByIndex = (lista, indeks) =>
[
... list.slice (0, index),
... list.slice (indeks + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (wyjście)
|
Możesz użyć lodash _.pull (mutate array), _.pullAt (mutate array) lub _.without (nie mutuje tablicy),
var tablica1 = ['a', 'b', 'c', 'd']
_.pull (tablica1, 'c')
console.log (tablica1) // ['a', 'b', 'd']
var tablica2 = ['e', 'f', 'g', 'h']
_.pullAt (tablica2, 0)
console.log (tablica2) // ['f', 'g', 'h']
var tablica3 = ['i', 'j', 'k', 'l']
var newArray = _.without (tablica3, 'i') // ['j', 'k', 'l']
console.log (tablica3) // ['i', 'j', 'k', 'l']
|
Usunięcie określonego elementu / ciągu znaków z tablicy można wykonać w jednej linijce:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
gdzie:
theArray: tablica, z której chcesz usunąć coś konkretnego
stringToRemoveFromArray: ciąg, który chcesz usunąć, a 1 to liczba elementów, które chcesz usunąć.
UWAGA: Jeśli "stringToRemoveFromArray" nie znajduje się w tablicy, spowoduje to usunięcie ostatniego elementu tablicy.
Zawsze warto sprawdzić, czy element istnieje w tablicy, zanim go usuniesz.
if (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Jeśli masz dostęp do nowszych wersji Ecmascript na komputerach swoich klientów (UWAGA, może nie działać na starszych stacjach):
zmienna tablica = ['1', '2', '3', '4', '5', '6']
var nowa tablica = tablica.filter ((wartość) => wartość! = '3');
Gdzie „3” to wartość, którą chcesz usunąć z tablicy.
Tablica wyglądałaby wtedy następująco: ['1', '2', '4', '5', '6']
|
OK, na przykład masz tablicę poniżej:
var num = [1, 2, 3, 4, 5];
Chcemy usunąć numer 4. Możesz po prostu użyć poniższego kodu:
num.splice (num.indexOf (4), 1); // num będzie [1, 2, 3, 5];
Jeśli używasz tej funkcji ponownie, piszesz funkcję wielokrotnego użytku, która zostanie dołączona do natywnej funkcji tablicy, jak poniżej:
Array.prototype.remove = Array.prototype.remove || function (x) {
const i = this.indexOf (x);
jeśli (i === - 1)
powrót;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}
Ale co powiesz na to, że zamiast tego masz poniższą tablicę z kilkoma [5] s w tablicy?
var num = [5, 6, 5, 4, 5, 1, 5];
Potrzebujemy pętli, aby sprawdzić je wszystkie, ale łatwiejszym i wydajniejszym sposobem jest użycie wbudowanych funkcji JavaScript, dlatego piszemy funkcję, która zamiast tego używa filtru takiego jak poniżej:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]
Istnieją również biblioteki innych firm, które pomagają to zrobić, takie jak Lodash lub Underscore. Aby uzyskać więcej informacji, zobacz lodash _.pull, _.pullAt lub _.without.
|
Występ
Dzisiaj (09.12.2019) przeprowadzam testy wydajności na macOS v10.13.6 (High Sierra) dla wybranych rozwiązań. Pokazuję delete (A), ale nie używam go w porównaniu z innymi metodami, ponieważ pozostawił puste miejsce w tablicy.
Wnioski
najszybszym rozwiązaniem jest array.splice (C) (z wyjątkiem Safari dla małych tablic, gdzie występuje drugi raz)
w przypadku dużych tablic array.slice + splice (H) jest najszybszym niezmiennym rozwiązaniem dla przeglądarek Firefox i Safari; Array.from (B) jest najszybszy w Chrome
rozwiązania mutowalne są zwykle 1,5x-6x szybsze niż niezmienne
w przypadku małych tabel w przeglądarce Safari zaskakująco zmienne rozwiązanie (C) jest wolniejsze niż niezmienne rozwiązanie (G)
Detale
W testach usuwam środkowy element z tablicy na różne sposoby. Rozwiązania A, C są na miejscu. Rozwiązania B, D, E, F, G, H są niezmienne.
Wyniki dla tablicy z 10 elementami
W Chrome array.splice (C) jest najszybszym rozwiązaniem w miejscu. Array.filter (D) jest najszybszym niezmiennym rozwiązaniem. Najwolniejszy to array.slice (F). Tutaj możesz przeprowadzić test na swoim komputerze.
Wyniki dla tablicy zawierającej 1 000 000 elementów
W Chrome array.splice (C) jest najszybszym rozwiązaniem na miejscu (usuwanie (C) jest podobnie szybkie - ale pozostawiło puste miejsce w tablicy (więc nie wykonuje pełnego usunięcia)). Array.slice-splice (H) jest najszybszym niezmiennym rozwiązaniem. Najwolniejszy to array.filter (D i E). Tutaj możesz przeprowadzić test na swoim komputerze.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (litera, tablica) => console.log (litera, tablica.join `,`);
function A (tablica) {
var index = array.indexOf (5);
usuń tablicę [indeks];
log ('A', tablica);
}
funkcja B (tablica) {
var index = array.indexOf (5);
var arr = Array.from (tablica);
arr.splice (index, 1)
log („B”, arr);
}
function C (tablica) {
var index = array.indexOf (5);
array.splice (indeks, 1);
log ('C', tablica);
}
function D (tablica) {
var arr = array.filter (item => item! == 5)
log ('D', arr);
}
funkcja E (tablica) {
var index = array.indexOf (5);
var arr = array.filter ((item, i) => i! == index)
log ('E', arr);
}
function F (tablica) {
var index = array.indexOf (5);
var arr = tablica.slice (0, indeks) .concat (tablica.slice (indeks + 1))
log („F”, arr);
}
function G (tablica) {
var index = array.indexOf (5);
var arr = [... tablica.slice (0, indeks), ... tablica.slice (indeks + 1)]
log ('G', arr);
}
function H (tablica) {
var index = array.indexOf (5);
var arr = tablica.slice (0);
arr.splice (indeks, 1);
log („H”, arr);
}
A ([... a]);
B ([... a]);
C ([... a]);
D ([... a]);
E ([... a]);
Fa]);
G ([... a]);
H ([... a]);
Ten fragment kodu przedstawia tylko kod używany w testach wydajności - sam nie wykonuje testów.
Porównanie dla przeglądarek: Chrome w wersji 78.0.0, Safari w wersji 13.0.4 i Firefox w wersji 71.0.0
|
Jestem całkiem nowy w JavaScript i potrzebowałem tej funkcji. Po prostu napisałem to:
function removeFromArray (tablica, pozycja, indeks) {
while ((index = array.indexOf (item))> -1) {
array.splice (indeks, 1);
}
}
Wtedy, gdy chcę go użyć:
// Skonfiguruj fikcyjne dane
var dummyObj = {imię: "miau"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];
// Usuń fikcyjne dane
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Wynik - zgodnie z oczekiwaniami.
["item1", "item1"]
Możesz mieć inne potrzeby niż ja, więc możesz je łatwo zmodyfikowaćdo nich pasować. Mam nadzieję, że to komuś pomoże.
|
Jeśli masz w tablicy złożone obiekty, możesz użyć filtrów?
W sytuacjach, gdy $ .inArray lub array.splice nie są tak łatwe w użyciu. Zwłaszcza jeśli obiekty są prawdopodobnie płytkie w tablicy.
Na przykład. jeśli masz obiekt z polem Id i chcesz, aby obiekt został usunięty z tablicy:
this.array = this.array.filter (function (element, i) {
return element.id! == idToRemove;
});
|
Chcę odpowiedzieć na podstawie ECMAScript 6. Załóżmy, że masz tablicę jak poniżej:
niech arr = [1, 2, 3, 4];
Jeśli chcesz usunąć w specjalnym indeksie, takim jak 2, napisz poniższy kod:
arr.splice (2, 1); // => arr stał się [1,2,4]
Ale jeśli chcesz usunąć specjalny element, taki jak 3, i nie znasz jego indeksu, wykonaj poniższe czynności:
arr = arr.filter (e => e! == 3); // => arr stał się [1,2,4]
Wskazówka: użyj funkcji strzałki do wywołania zwrotnego filtru, chyba że otrzymasz pustą tablicę.
|
Aktualizacja: ta metoda jest zalecana tylko wtedy, gdy nie możesz użyć ECMAScript 2015 (wcześniej znanego jako ES6). Jeśli możesz go użyć, inne odpowiedzi tutaj zapewniają znacznie zgrabniejsze implementacje.
To streszczenie rozwiąże twój problem, a także usunie wszystkie wystąpienia argumentu zamiast tylko 1 (lub określonej wartości).
Array.prototype.destroy = function (obj) {
// Zwróć wartość null, jeśli nie znaleziono i nie usunięto żadnych obiektów
var zniszczone = null;
for (var i = 0; i 3
x.destroy (false); // => fałsz
x; // => [1, 2, true, undefined]
x.destroy (prawda); // => prawda
x.destroy (nieokreślony); // => niezdefiniowany
x; // => [1, 2]
x.destroy (3); // => null
x; // => [1, 2]
|
Aktualizacja ES10
Ten post zawiera podsumowanie typowych podejść do usuwania elementów z tablicy od ECMAScript 2019 (ES10).
1. Przypadki ogólne
1.1. Usuwanie elementu Array według wartości za pomocą .splice ()
| Na miejscu: tak |
| Usuwa duplikaty: tak (pętla), nie (indexOf) |
| Według wartości / indeksu: Według indeksu |
Jeśli znasz wartość, którą chcesz usunąć z tablicy, możesz użyć metody łączenia. Najpierw musisz określić indeks elementu docelowego. Następnie używasz indeksu jako elementu początkowego i usuwasz tylko jeden element.
// Z pętlą „for”
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for (niech i = 0; i [1, 2, 3, 4, 6, 7, 8, 9, 0]
// Z metodą .indexOf ()
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Usuwanie elementu Array za pomocą metody .filter ()
| Na miejscu: nie |
| Usuwa duplikaty: Tak |
| Według wartości / indeksu: Według wartości |
Określony element można odfiltrować z tablicy, zapewniając funkcję filtrowania. Taka funkcja jest następnie wywoływana dla każdego elementu tablicy.
wartość const = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == value)
console.log (arr)
// [1, 2, 4, 5]
1.3. Usunięcie elementu Array poprzez rozszerzenie Array.prototype
| Na miejscu: tak / nie (w zależności od wdrożenia) |
| Usuwa duplikaty: tak / nie (w zależności od implementacji) |
| Według wartości / indeksu: Według indeksu / Według wartości (w zależności od implementacji) |
Prototyp tablicy można rozszerzyć o dodatkowe metody. Takie metody będą wtedy dostępne do użycia na utworzonych tablicach.
Uwaga: Rozszerzanie prototypów obiektów ze standardowej biblioteki JavaScript (takiej jak Array) jest przez niektórych uważane za antywzór.
// Lokalnie, usuwa wszystko według implementacji wartości
Array.prototype.remove = function (item) {
for (niech i = 0; i = ES10)
| Na miejscu: nie |
| Usuwa duplikaty: Tak |
| Według wartości / indeksu: Według wartości |
ES10 wprowadził Object.fromEntries, którym może byćsłuży do tworzenia żądanej tablicy z dowolnego obiektu podobnego do tablicy i filtrowania niepożądanych elementów podczas procesu.
const obiekt = [1, 2, 3, 4];
const valueToRemove = 3;
const arr = Object.values (Object.fromEntries (
Object.entries (obiekt)
.filter (([klucz, wartość]) => val! == wartośćToRemove)
));
console.log (arr); // [1, 2, 4]
2. Przypadki specjalne
2.1 Usuwanie elementu, jeśli znajduje się na końcu tablicy
2.1.1. Zmiana długości tablicy
| Na miejscu: tak |
| Usuwa duplikaty: Nie |
| Według wartości / indeksu: nie dotyczy |
Elementy tablicy JavaScript można usunąć z końca tablicy, ustawiając właściwość length na wartość mniejszą niż wartość bieżąca. Każdy element, którego indeks jest większy lub równy nowej długości, zostanie usunięty.
const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Ustaw długość, aby usunąć element
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Korzystanie z metody .pop ()
| Na miejscu: tak |
| Usuwa duplikaty: Nie |
| Według wartości / indeksu: nie dotyczy |
Metoda pop usuwa ostatni element tablicy, zwraca ten element i aktualizuje właściwość length. Metoda pop modyfikuje tablicę, na której jest wywoływana, co oznacza, w przeciwieństwie do usuwania, ostatni element jest całkowicie usuwany, a długość tablicy jest zmniejszona.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // zwraca 6
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Usuwanie elementu, jeśli znajduje się na początku tablicy
| Na miejscu: tak |
| Usuwa duplikaty: Nie |
| Według wartości / indeksu: nie dotyczy |
Metoda .shift () działa podobnie jak metoda pop, z tą różnicą, że usuwa pierwszy element tablicy JavaScript zamiast ostatniego. Po wyjęciu elementu pozostałe elementy są przesuwane w dół.
const arr = [1, 2, 3, 4];
arr.shift (); // zwraca 1
console.log (arr); // [2, 3, 4]
2.3. Usuwanie elementu, jeśli jest to jedyny element w tablicy
| Na miejscu: tak |
| Usuwa duplikaty: nie dotyczy |
| Według wartości / indeksu: nie dotyczy |
Najszybszą techniką jest ustawienie zmiennej tablicowej na pustą tablicę.
let arr = [1];
arr = []; // pusta tablica
Alternatywnie można zastosować technikę z 2.1.1, ustawiając długość na 0.
|
Nigdy nie powinieneś modyfikować swojej tablicy. Ponieważ jest to sprzeczne z funkcjonalnym wzorcem programowania. Możesz utworzyć nową tablicę bez odwoływania się do tablicy, w której chcesz zmienić dane, używając filtru metody ECMAScript 6;
var myArray = [1, 2, 3, 4, 5, 6];
Załóżmy, że chcesz usunąć 5 z tablicy, możesz to po prostu zrobić w ten sposób:
myArray = myArray.filter (wartość => wartość! == 5);
To da ci nową tablicę bez wartości, którą chciałeś usunąć. Wynik będzie więc:
[1, 2, 3, 4, 6]; // 5 zostało usunięte z tej tablicy
Aby lepiej zrozumieć, możesz przeczytać dokumentację MDN na Array.filter.
|
Bardziej nowoczesne podejście, ECMAScript 2015 (wcześniej znane jako Harmony lub ES 6). Dany:
elementy const = [1, 2, 3, 4];
indeks const = 2;
Następnie:
items.filter ((x, i) => i! == indeks);
Wydajność:
[1, 2, 4]
Możesz użyć Babel i usługi polyfill, aby upewnić się, że jest to dobrze obsługiwane we wszystkich przeglądarkach.
|
Możesz wykonać pętlę wsteczną, aby upewnić się, że nie zepsujesz indeksów, jeśli istnieje wiele wystąpień elementu.
var myElement = "czekolada";
var myArray = ['czekolada', 'poptart', 'poptart', 'poptart', 'czekolada', 'poptart', 'poptart', 'czekolada'];
/ * Ważny kod * /
for (var i = myArray.length - 1; i> = 0; i--) {
if (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Live Demo
|
Masz w tablicy od 1 do 9 i chcesz usunąć 5. Użyj poniższego kodu:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
powrót m! == 5;
});
console.log ("nowa tablica, 5 usuniętych", newNumberArray);
Jeśli chcesz mieć wiele wartości. Przykład: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
return (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("nowa tablica, 1,7 i 8 usunięta", newNumberArray);
Jeśli chcesz usunąć wartość tablicy z tablicy. Przykład: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
return! removebleArray.includes (m);
});
console.log ("nowa tablica, [3,4,5] usunięta", newNumberArray);
Zawiera obsługiwaną przeglądarkę to link.
|
1
2
3
4
Kolejny
Bardzo aktywne pytanie. Zdobądź 10 punktów reputacji, aby odpowiedzieć na to pytanie. Wymóg dotyczący reputacji pomaga chronić to pytanie przed spamem i brakiem odpowiedzi.
Nie szukasz odpowiedzi? Przeglądaj inne pytania otagowane tablice javascript lub zadaj własne pytanie.